home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / iutil / get_tuple.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-18  |  3.8 KB  |  198 lines
  1. # include    <ingres.h>
  2. # include    <access.h>
  3. # include    <symbol.h>
  4. # include    <catalog.h>
  5. # include    <btree.h>
  6. # include    <sccs.h>
  7.  
  8. SCCSID(@(#)get_tuple.c    8.3    5/1/86)
  9.  
  10. /*
  11. **    Routine associated with getting a tuple out of
  12. **    the current buffer.
  13. */
  14.  
  15.  
  16. /*
  17. **    Get_tuple - take the tuple specified
  18. **    by tid and move it to "tuple"
  19. */
  20.  
  21. get_tuple(d, tid, tuple)
  22. register DESC    *d;
  23. TID        *tid;
  24. char        *tuple;
  25. {
  26.     register char    *cp;
  27.     char        *get_addr();
  28.     TID        tidloc;
  29.     char        lid[MAXLID * LIDSIZE];
  30.     extern DESC    Btreesec;
  31.     extern int    Btree_fd;
  32.  
  33.     cp = get_addr(tid);
  34.  
  35.     if (d->reldum.relspec < 0)
  36.         uncomp_tup(d, cp, tuple);    /* compressed tuple */
  37.     else
  38.     {
  39.         if (d->reldum.reldim == 0)
  40.             bmove(cp, tuple, d->reldum.relwid);    /* uncompressed tuple */
  41.         else
  42.             /* ignore lid field for now */
  43.             bmove(cp, tuple, d->reldum.relwid - d->reldum.reldim * LIDSIZE);
  44.     }
  45.  
  46.     if (d->reldum.reldim > 0)
  47.     /* find corresponding lid value given main relation tid */
  48.     {
  49.         bmove(d->relbtree, &Btreesec, sizeof(Btreesec));
  50.         Btree_fd = d->btree_fd;
  51.         search_btree(*tid, &tidloc);
  52.         get_lid(&tidloc, lid);
  53.         /* attach lid value to end of tuple */
  54.         cp = tuple + d->reldum.relwid - d->reldum.reldim * LIDSIZE;
  55.         bmove(lid, cp, d->reldum.reldim * LIDSIZE);
  56.     }
  57. }
  58. /*
  59. **    Getint_tuple - get the tuple specified by
  60. **    tid. If possible avoid moving the tuple.
  61. **    Return value is address of tuple.
  62. */
  63.  
  64. char *
  65. getint_tuple(d, tid, tuple)
  66. register DESC    *d;
  67. TID        *tid;
  68. char        *tuple;
  69. {
  70.     register char    *cp, *ret;
  71.     extern char    *get_addr();
  72.     TID        tidloc;
  73.     char        lid[MAXLID * LIDSIZE];
  74.     extern DESC    Btreesec;
  75.     extern int    Btree_fd;
  76.  
  77.     cp = get_addr(tid);
  78.  
  79.     if (d->reldum.relspec < 0)
  80.     {
  81.         ret = tuple;
  82.         uncomp_tup(d, cp, ret);    /* compressed tuple */
  83.     }
  84.     else if (d->reldum.reldim == 0)
  85.         ret = cp;            /* uncompressed tuple */
  86.     else
  87.     {
  88.         /* ignore lid field for now */
  89.         ret = tuple;
  90.         bmove(cp, tuple, d->reldum.relwid - d->reldum.reldim * LIDSIZE);
  91.     }
  92.     if (d->reldum.reldim > 0)
  93.     {
  94.         bmove(d->relbtree, &Btreesec, sizeof(Btreesec));
  95.         Btree_fd = d->btree_fd;
  96.         /* find corresponding lid value */
  97.         search_btree(*tid, &tidloc);
  98.         get_lid(&tidloc, lid);
  99.         /* attach lid value to end of tuple */
  100.         cp = ret + d->reldum.relwid - d->reldum.reldim * LIDSIZE;
  101.         bmove(lid, cp, d->reldum.reldim * LIDSIZE);
  102.     }
  103.     return (ret);
  104. }
  105. /*
  106. **    Routine to compute the address of a tuple
  107. **    within the current buffer.
  108. **    Syserr if specified tuple deleted.
  109. */
  110.  
  111. char *
  112. get_addr(tid)
  113. register TID    *tid;
  114. {
  115.     register int    offset;
  116.  
  117.     offset = Acc_head->linetab[-(tid->line_id & I1MASK)];
  118.     if (offset == 0)
  119.     {
  120.         syserr("get_addr rel=%ld tid=%ld", Acc_head->rel_tupid, *(long *)tid);
  121.     }
  122. #    ifdef xATR3
  123.     if (offset < 0 || offset > PGSIZE)
  124.         syserr("get_addr: offset=%d\n");
  125. #    endif
  126.     return (((char *) Acc_head) + offset);
  127. }
  128. /*
  129. **    Uncompress - decompress the tuple at address cp
  130. **    according to descriptor.
  131. */
  132.  
  133. uncomp_tup(d, cp, tuple)
  134. register DESC    *d;
  135. char        *cp;
  136. char        *tuple;
  137. {
  138.     register char    *src, *dst, *start;
  139.     int        i, j, numatts;
  140.  
  141.     dst = tuple;
  142.     src = cp;
  143.     start = dst - d->reloff[1];
  144.  
  145.     /* for each domain, copy and blank pad if char */
  146.     /* ignore lid field */
  147.     numatts = d->reldum.relatts - d->reldum.reldim;
  148.     for (i = 1; i <= numatts; i++)
  149.     {
  150.         j = d->relfrml[i] & I1MASK;
  151.         dst = start + d->reloff[i];
  152.         if (d->relfrmt[i] == CHAR)
  153.         {
  154.             while (j--)
  155.             {
  156.                 if ((*dst++ = *src++) == (char *)NULL)
  157.                 {
  158.                     /* back up one */
  159.                     dst--;
  160.                     j++;
  161.                     break;
  162.                 }
  163.             }
  164.  
  165.             /* blank pad if necessary */
  166.             while (j-- > 0)
  167.                 *dst++ = ' ';
  168.         }
  169.         else
  170.         {
  171.             while (j--)
  172.                 *dst++ = *src++;
  173.         }
  174.     }
  175. }
  176. /*
  177. **    Check if a line number is valid.
  178. **    If linenumber is illegal return AMINVL_ERR
  179. **    if Line has been deleted return DELTUP
  180. **    else return 0
  181. */
  182.  
  183. invalid(tid)
  184. register TID    *tid;
  185. {
  186.     register int    i;
  187.  
  188.     i = tid->line_id & I1MASK;
  189.  
  190.     if (i >= Acc_head->nxtlino)
  191.         return (acc_err(AMINVL_ERR));
  192.  
  193.     if (Acc_head->linetab[-i] == 0)
  194.         return (DELTUP);
  195.  
  196.     return (0);
  197. }
  198.